Par DocuGenerate Bien que DocuGenerate fonctionne principalement avec des documents Word, de nombreuses équipes préfèrent créer et modifier leurs modèles dans Google Docs en raison de ses fonctionnalités de collaboration supérieures, de ses capacités d’édition en temps réel et de son interface intuitive. Cependant, utiliser des modèles Google Docs dans DocuGenerate nécessite traditionnellement un processus manuel : télécharger le Google Doc en tant que fichier Word, puis le téléverser dans DocuGenerate. Bien que cette approche fonctionne, elle crée des frictions dans votre workflow et rend la maintenance des modèles fastidieuse, surtout lorsque les modèles changent fréquemment.
Et si vous pouviez éliminer entièrement cette étape manuelle? Et si vos Google Docs pouvaient se synchroniser automatiquement avec DocuGenerate, créant de nouveaux modèles lorsque des documents sont ajoutés et mettant à jour les modèles existants lorsque des modifications sont apportées? Cette automatisation permettrait à votre équipe de continuer à travailler dans Google Docs tout en garantissant que vos modèles DocuGenerate restent à jour sans aucune intervention manuelle.
Dans ce tutoriel complet, nous allons créer une solution de synchronisation complète utilisant Google Apps Script qui surveille un dossier Google Drive spécifique et synchronise automatiquement toutes les modifications avec votre compte DocuGenerate. Le système gère à la fois la création initiale des modèles et leurs mises à jour continues, ce qui le rend parfait pour les équipes qui souhaitent conserver leur workflow Google Docs tout en exploitant les puissantes capacités de génération de documents de DocuGenerate.
Notre script de synchronisation surveille un dossier Google Drive désigné pour détecter les modifications et traite automatiquement tout document modifié, garantissant que vos modèles DocuGenerate reflètent toujours la dernière version de vos Google Docs. Le workflow de synchronisation suit cette séquence logique :
Détection des Documents : Le système analyse votre dossier Google Drive désigné à la recherche de Google Docs, identifiant à la fois les nouveaux documents qui n’ont pas encore été synchronisés et les documents existants qui ont été modifiés récemment.
Mappage des Modèles : Pour chaque document, le script vérifie s’il correspond déjà à un modèle DocuGenerate en examinant les propriétés personnalisées du document. Ces propriétés agissent comme un pont entre les deux systèmes, stockant l’ID du modèle DocuGenerate directement dans les métadonnées du Google Doc.
Conversion de Format : Lorsqu’un document doit être synchronisé, le script le convertit du format Google Docs vers le format Microsoft Word (.docx), qui est le format attendu par DocuGenerate pour le traitement des modèles.
Communication API : Selon que le document est nouveau ou existant, l’automatisation crée un nouveau modèle dans DocuGenerate ou met à jour un modèle existant via l’API DocuGenerate.
Stockage des Métadonnées : Après une synchronisation réussie, le script stocke l’ID du modèle DocuGenerate dans les propriétés personnalisées du Google Doc, garantissant que les futures mises à jour modifieront le bon modèle plutôt que d’en créer des doublons.
Cette conception garantit que votre équipe peut continuer à travailler naturellement dans Google Docs tandis que la synchronisation automatisée gère tous les détails techniques pour maintenir les modèles DocuGenerate à jour. Vous pouvez consulter le script complet que nous allons construire dans ce tutoriel, si vous voulez avoir une idée de son fonctionnement global.
Google Apps Script fournit une plateforme puissante pour automatiser les workflows entre les applications Google Workspace et les API externes. Pour notre solution de synchronisation, nous allons créer un nouveau projet Apps Script contenant toutes les fonctions nécessaires pour surveiller les Google Docs et communiquer avec DocuGenerate.
Pour commencer, accédez à Apps Script et créez un nouveau projet. Vous commencerez avec une page vierge où nous pourrons construire notre solution de synchronisation complète. Notre projet pour ce tutoriel s’appelle Templates Sync DocuGenerate, comme vous pouvez le voir dans l’image ci-dessous.
Notre script de synchronisation a besoin d’accéder à des fonctionnalités avancées de Google Drive qui vont au-delà du service DriveApp standard. Plus précisément, nous avons besoin de l’ API Google Drive v3 pour travailler avec les propriétés personnalisées des fichiers, qui est la méthode que nous utiliserons pour suivre la relation entre les Google Docs et les modèles DocuGenerate.
Pour activer l’API Google Drive dans votre projet Apps Script nouvellement créé, cliquez sur Add a service dans la barre latérale gauche de l’éditeur Apps Script. 
Recherchez ensuite Drive API, définissez l’identifiant sur Drive et cliquez sur le bouton Add pour terminer la configuration. 
Cette étape est cruciale car le service DriveApp standard ne donne pas accès aux propriétés personnalisées des fichiers, que nous utilisons pour stocker l’ID du modèle DocuGenerate dans les métadonnées de chaque Google Doc. Sans cet accès à l’API, notre script ne pourrait pas savoir quels documents ont déjà été synchronisés ni déterminer s’il faut créer de nouveaux modèles ou mettre à jour des modèles existants.
Avant de mettre en œuvre les fonctions de synchronisation, vous devrez configurer le système avec vos identifiants et paramètres spécifiques. Notre script utilise un objet de configuration qui centralise tous les paramètres que vous devez personnaliser :
const CONFIG = {
DOCUGENERATE_API_KEY: 'YOUR_API_KEY_HERE', // Get from DocuGenerate settings
DOCUGENERATE_BASE_URL: 'https://api.docugenerate.com/v1', // Change region if needed
MONITORED_FOLDER_ID: 'YOUR_FOLDER_ID_HERE' // Google Drive folder ID to monitor
};
DOCUGENERATE_API_KEY : Vous pouvez trouver votre clé API dans la page Paramètres Développeurs. Cette clé authentifie toutes les demandes adressées à l’API DocuGenerate et garantit que les modèles générés sont correctement associés à votre compte.
DOCUGENERATE_BASE_URL : L’URL par défaut pointe vers la région de traitement principale de DocuGenerate. Si vous utilisez un point de terminaison régional pour un traitement plus rapide dans votre zone géographique, mettez à jour cette URL en conséquence.
MONITORED_FOLDER_ID : Il s’agit de l’identifiant unique du dossier Google Drive que vous souhaitez surveiller. Vous pouvez extraire l’ID du dossier à partir de n’importe quelle URL Google Drive : https://drive.google.com/drive/folders/<FOLDER_ID>
La fonction de synchronisation manuelle constitue la base de notre solution de synchronisation et fournit le mécanisme de configuration initial pour établir les connexions entre vos Google Docs et les modèles DocuGenerate. Cette fonction traite tous les documents de votre dossier surveillé, peu importe la date de leur dernière modification, ce qui la rend parfaite pour une configuration initiale ou des opérations de synchronisation en masse.
/**
* Manual sync function - syncs all documents in the monitored folder
* Useful for initial setup or bulk sync
*/
function manualSync() {
try {
console.log('Starting manual sync of all documents...');
const folder = DriveApp.getFolderById(CONFIG.MONITORED_FOLDER_ID);
console.log(`Processing folder: ${folder.getName()}`);
const files = folder.getFilesByType(MimeType.GOOGLE_DOCS);
while (files.hasNext()) {
const file = files.next();
console.log(`Processing: ${file.getName()}`);
syncDocument(file);
}
console.log('Manual sync completed!');
} catch (error) {
console.error('Error in manual sync:', error);
}
}
Cette fonction illustre plusieurs concepts clés utilisés tout au long de notre script de synchronisation :
Accès au Dossier : La fonction utilise DriveApp.getFolderById() pour accéder au dossier spécifique que nous voulons surveiller. Cette approche garantit que seuls les documents du dossier désigné sont traités, évitant la synchronisation accidentelle de documents sans rapport.
Filtrage par Type de Fichier : En utilisant getFilesByType(MimeType.GOOGLE_DOCS), la fonction filtre automatiquement tout fichier qui n’est pas un Google Doc dans le dossier. Cela garantit que seuls les documents pouvant être convertis au format Word sont traités.
Modèle d’Itérateur : Google Apps Script utilise des itérateurs pour les collections de fichiers afin de gérer efficacement un grand nombre de fichiers. La boucle while (files.hasNext()) traite chaque fichier individuellement, permettant une journalisation détaillée et une gestion des erreurs par document.
Délégation à la Logique Principale : Le travail de synchronisation réel est géré par la fonction syncDocument(), que nous examinerons ensuite. Cette séparation des responsabilités rend le code plus facile à maintenir et permet d’utiliser la même logique principale pour les opérations de synchronisation manuelle et automatique.
Gestion des Erreurs : L’ensemble de l’opération est encapsulé dans un bloc try-catch pour garantir que toute erreur survenant pendant le traitement est correctement journalisée et n’interrompt pas l’ensemble de l’opération de synchronisation. Ceci est particulièrement important pour les scripts automatisés qui doivent s’exécuter de manière fiable dans le temps.
Vous devez exécuter cette fonction en premier lors de la configuration de votre automatisation de synchronisation, car elle établit les mappages initiaux entre vos Google Docs existants et leurs modèles DocuGenerate correspondants.
La fonction syncDocument() contient la logique principale qui gère le processus de synchronisation pour les documents individuels. Cette fonction est responsable de déterminer si un document doit créer un nouveau modèle ou mettre à jour un modèle existant, de gérer le processus de conversion, et de maintenir les métadonnées qui suivent la relation entre les Google Docs et les modèles DocuGenerate.
/**
* Syncs a Google Doc to DocuGenerate
*/
function syncDocument(doc) {
try {
const docId = doc.getId();
const docName = doc.getName();
console.log(`Syncing document: ${docName} (${docId})`);
// Check if document already has a template ID
const docMetadata = Drive.Files.get(docId, {
fields: 'properties'
});
const docProperties = docMetadata.properties || {};
const existingTemplateId = docProperties['docugenerate_template_id'];
// Convert Google Doc to Word format
const wordBlob = convertToWordFormat(docId, docName);
if (existingTemplateId) {
console.log(`Updating existing template: ${existingTemplateId}`);
updateTemplate(existingTemplateId, wordBlob, docName);
} else {
console.log('Creating new template');
const templateId = createTemplate(wordBlob, docName);
if (templateId) {
// Store the template ID in document properties
Drive.Files.update({
properties: {
'docugenerate_template_id': templateId
}
}, docId);
}
}
} catch (error) {
console.error('Error syncing document:', error);
}
}
Cette fonction illustre plusieurs concepts sophistiqués qui rendent la solution de synchronisation robuste et intelligente :
Inspection des Métadonnées : La fonction utilise l’API Google Drive v3 pour examiner les propriétés personnalisées du document. Ces propriétés sont invisibles pour les utilisateurs mais offrent un moyen puissant de stocker des métadonnées qui persistent avec le document. L’appel Drive.Files.get() demande spécifiquement uniquement le champ properties pour minimiser l’utilisation de l’API et améliorer les performances.
Logique de Décision : Selon que le document possède déjà ou non une propriété docugenerate_template_id, la fonction décide s’il faut créer un nouveau modèle ou mettre à jour un modèle existant. Cette logique de décision évite les doublons de modèles et garantit que les modifications de documents entraînent des mises à jour de modèles plutôt que la création de nouveaux modèles.
Conversion de Format : Chaque opération de synchronisation nécessite de convertir le Google Doc au format Word, ce qui est géré par la fonction convertToWordFormat(). Cette conversion garantit que DocuGenerate reçoit le modèle dans un format qu’il peut traiter de manière fiable.
Persistance des Métadonnées : Lorsqu’un nouveau modèle est créé avec succès dans DocuGenerate, la fonction stocke l’ID de modèle renvoyé dans les propriétés du document à l’aide de Drive.Files.update(). Cela crée un lien permanent entre le Google Doc et son modèle DocuGenerate correspondant.
Gestion Élégante des Erreurs : Les erreurs sur un document individuel n’arrêtent pas le processus de synchronisation global. Si un document ne parvient pas à se synchroniser, l’erreur est journalisée, mais le système continue de traiter les autres documents.
Cette approche garantit que le système de synchronisation se comporte de manière intelligente et maintient l’intégrité des données sur les deux plateformes. Le mécanisme de stockage des métadonnées est particulièrement élégant car il est totalement invisible pour les utilisateurs tout en fournissant au système les informations nécessaires pour prendre des décisions intelligentes concernant la gestion des modèles.
Le processus de conversion de document est un composant essentiel de notre solution de synchronisation, car DocuGenerate s’attend à recevoir les modèles au format Microsoft Word (.docx). Google Apps Script fournit une fonctionnalité intégrée pour exporter les Google Docs dans divers formats, et nous exploitons cette fonctionnalité pour créer des documents Word correctement formatés qui conservent tout le formatage, les styles et les balises de fusion du Google Doc d’origine.
/**
* Converts a Google Doc to Word format (.docx)
*/
function convertToWordFormat(docId, docName) {
try {
// Export as Word document
const url = `https://docs.google.com/document/d/${docId}/export?format=docx`;
const response = UrlFetchApp.fetch(url, {
headers: {
'Authorization': 'Bearer ' + ScriptApp.getOAuthToken()
}
});
// Return blob with proper name and content type
return response.getBlob()
.setName(`${docName}.docx`)
.setContentType(MimeType.MICROSOFT_WORD);
} catch (error) {
console.error('Error converting to Word format:', error);
throw error;
}
}
Cette fonction illustre plusieurs concepts techniques importants :
API d’Export de Google : Google fournit une URL d’export directe pour chaque document, capable de générer le document dans divers formats. Le paramètre format=docx demande spécifiquement le format Microsoft Word, ce qui garantit la compatibilité avec le système de traitement des modèles de DocuGenerate.
Authentification OAuth : Le processus de conversion nécessite une authentification pour accéder aux Google Docs privés. La méthode ScriptApp.getOAuthToken() fournit le jeton OAuth nécessaire qui accorde au script l’accès au document au nom de l’utilisateur qui a autorisé le script.
Gestion des Blobs : Google Apps Script représente les fichiers sous forme de « blobs » - des objets binaires volumineux qui contiennent les données du fichier ainsi que des métadonnées comme le nom de fichier et le type de contenu. La fonction définit correctement à la fois le nom de fichier (en ajoutant l’extension .docx) et le type MIME pour garantir que le fichier résultant est reconnu comme un document Word valide.
Propagation des Erreurs : Contrairement à d’autres fonctions qui capturent et journalisent les erreurs localement, cette fonction relance les erreurs vers la fonction appelante. Cette conception garantit que si la conversion du document échoue, la fonction appelante peut gérer l’erreur de manière appropriée (par exemple, en ignorant le document ou en réessayant plus tard).
Gestion des Noms de Fichiers : La fonction ajoute automatiquement l’extension .docx au nom du document, garantissant que le fichier résultant possède la bonne extension, quel que soit le nom du Google Doc d’origine.
Ce processus de conversion préserve tous les aspects importants de votre Google Doc, y compris le formatage du texte, les tableaux, les images, et surtout, les balises de fusion que DocuGenerate utilisera lors de la génération des documents. Le document Word résultant est fonctionnellement identique à ce que vous obtiendriez en exportant manuellement le Google Doc via l’interface Google Docs.
Lorsqu’un Google Doc n’a pas de modèle DocuGenerate associé (indiqué par l’absence d’une propriété docugenerate_template_id), le système doit créer un nouveau modèle dans DocuGenerate. Cette fonction gère la communication API nécessaire pour téléverser le document Word converti et l’établir comme nouveau modèle dans votre compte DocuGenerate.
/**
* Creates a new template in DocuGenerate
*/
function createTemplate(wordBlob, templateName) {
try {
const payload = {
'file': wordBlob,
'name': templateName
};
const options = {
method: 'POST',
headers: {
'Authorization': CONFIG.DOCUGENERATE_API_KEY
// Don't set Content-Type - Apps Script will handle it automatically
},
payload: payload
};
const response = UrlFetchApp.fetch(
`${CONFIG.DOCUGENERATE_BASE_URL}/template`,
options
);
if (response.getResponseCode() === 201) {
const responseData = JSON.parse(response.getContentText());
console.log('Template created successfully:', responseData.id);
return responseData.id;
} else {
console.error('Error creating template:', response.getContentText());
return null;
}
} catch (error) {
console.error('Error creating template:', error);
return null;
}
}
Cette fonction met en valeur plusieurs aspects importants de l’intégration d’API et de la gestion des formulaires multipart :
Données de Formulaire Multipart : La création d’un modèle nécessite de téléverser à la fois un fichier (le document Word) et des métadonnées (le nom du modèle). Cette fonction construit une charge utile de formulaire multipart qui inclut les deux éléments d’information dans le format attendu par l’API DocuGenerate.
Gestion Automatique du Content-Type : Un détail crucial est que nous évitons délibérément de définir manuellement l’en-tête Content-Type. Lorsque vous incluez des fichiers dans la charge utile, Google Apps Script doit ajouter des paramètres de délimitation au type de contenu multipart/form-data. En omettant l’en-tête Content-Type, nous laissons Apps Script gérer cela automatiquement, évitant les erreurs liées aux délimitations.
Vérification du Code de Statut HTTP : L’API DocuGenerate renvoie un code de statut 201 Created lorsqu’un modèle est créé avec succès. La fonction vérifie spécifiquement ce code de statut pour distinguer les opérations réussies des erreurs, garantissant une gestion robuste des erreurs.
Analyse de la Réponse : Lorsque la création du modèle réussit, l’API renvoie une réponse JSON contenant l’ID du nouveau modèle. Cet ID est crucial car c’est ce que nous allons stocker dans les propriétés du Google Doc pour lier le document à son modèle correspondant.
Retours d’Erreur Élégants : Plutôt que de lever des exceptions, cette fonction renvoie null en cas d’erreur. Cette approche permet à la fonction appelante de continuer à traiter d’autres documents même si la création d’un modèle échoue.
Journalisation Complète : La fonction fournit une journalisation détaillée à la fois pour les opérations réussies et les erreurs, facilitant le diagnostic des problèmes pendant le développement et le suivi des performances du système en production.
Le processus de création de modèle établit le lien fondamental entre votre Google Doc et DocuGenerate. Une fois ce lien établi via le mécanisme de stockage des métadonnées, toutes les futures modifications du Google Doc entraîneront des mises à jour de modèle plutôt que la création de modèles supplémentaires.
Lorsqu’un Google Doc possède déjà un modèle DocuGenerate associé (indiqué par la présence d’une propriété docugenerate_template_id), le système met à jour le modèle existant plutôt que d’en créer un nouveau. Cette fonction gère la communication API nécessaire pour remplacer le contenu du modèle tout en conservant l’ID du modèle et tous les paramètres associés dans DocuGenerate.
/**
* Updates an existing template in DocuGenerate
*/
function updateTemplate(templateId, wordBlob, templateName) {
try {
const payload = {
'file': wordBlob,
'name': templateName
};
const options = {
method: 'PUT',
headers: {
'Authorization': CONFIG.DOCUGENERATE_API_KEY
// Don't set Content-Type - Apps Script will handle it automatically
},
payload: payload
};
const response = UrlFetchApp.fetch(
`${CONFIG.DOCUGENERATE_BASE_URL}/template/${templateId}`,
options
);
if (response.getResponseCode() === 200) {
const responseData = JSON.parse(response.getContentText());
console.log('Template updated successfully:', templateId);
return true;
} else {
console.error('Error updating template:', response.getContentText());
return false;
}
} catch (error) {
console.error('Error updating template:', error);
return false;
}
}
Cette fonction partage de nombreuses similitudes avec la fonction de création de modèle, mais comporte quelques différences importantes :
Méthode HTTP : Les mises à jour de modèle utilisent la méthode PUT plutôt que POST, suivant les conventions des API RESTful. La méthode PUT indique que nous remplaçons entièrement la ressource existante par un nouveau contenu.
Structure de l’URL : L’URL inclut l’ID de modèle spécifique que nous mettons à jour (/template/${templateId}), garantissant que l’opération de mise à jour cible le bon modèle dans votre compte DocuGenerate.
Codes de Statut Attendus : Les mises à jour réussies renvoient un code de statut 200 OK plutôt que 201 Created, reflétant la différence entre la création de nouvelles ressources et la mise à jour de ressources existantes.
Sémantique de la Valeur de Retour : La fonction renvoie un booléen indiquant le succès ou l’échec plutôt qu’un ID de ressource comme la fonction de création. Puisque l’ID du modèle ne change pas pendant les mises à jour, il n’est pas nécessaire de le renvoyer.
Remplacement du Contenu : L’opération de mise à jour remplace entièrement le contenu du modèle par la nouvelle version provenant du Google Doc. Cela garantit que toutes les modifications, y compris les changements de texte, les mises à jour de formatage et les ajustements de balises de fusion, sont reflétées dans le modèle DocuGenerate.
Préservation des Paramètres : Bien que le contenu du modèle soit remplacé, les autres paramètres DocuGenerate associés au modèle restent inchangés. Cela offre le meilleur des deux mondes : un contenu actuel avec une configuration préservée.
Le mécanisme de mise à jour est crucial pour maintenir la synchronisation au fil du temps. À mesure que votre équipe collabore sur Google Docs et apporte des modifications aux modèles, cette fonction garantit que vos modèles DocuGenerate restent automatiquement à jour sans aucune intervention manuelle.
Bien que la synchronisation manuelle soit utile pour la configuration initiale et les opérations en masse, la véritable puissance de notre solution provient de la synchronisation automatique qui s’exécute continuellement en arrière-plan. Cette automatisation garantit que vos modèles DocuGenerate restent à jour à mesure que votre équipe apporte des modifications aux Google Docs, sans nécessiter d’intervention manuelle.
Google Apps Script fournit un puissant mécanisme de déclencheurs qui peut exécuter des fonctions selon un planning. Notre solution de synchronisation automatique utilise des déclencheurs temporels pour vérifier périodiquement les modifications de documents et les traiter automatiquement.
/**
* Sets up automatic sync with time-based triggers
* Run this function once to initialize the sync
*/
function setupAutoSync() {
try {
// Delete existing triggers to avoid duplicates
const triggers = ScriptApp.getProjectTriggers();
triggers.forEach(trigger => {
if (trigger.getHandlerFunction() === 'autoSync') {
ScriptApp.deleteTrigger(trigger);
}
});
// Create time-based trigger that runs every 5 minutes
ScriptApp.newTrigger('autoSync')
.timeBased()
.everyMinutes(5)
.create();
console.log('Auto-sync setup completed successfully!');
console.log('Monitored folder:', CONFIG.MONITORED_FOLDER_ID);
} catch (error) {
console.error('Error setting up auto-sync:', error);
}
}
Cette fonction de configuration illustre plusieurs concepts importants pour une automatisation robuste :
Prévention des Doublons : Avant de créer un nouveau déclencheur, la fonction supprime tout déclencheur existant qui appellerait la même fonction. Cela évite la création de plusieurs déclencheurs superposés si la fonction de configuration est exécutée plusieurs fois.
Configuration du Déclencheur : Le déclencheur est configuré pour s’exécuter toutes les 5 minutes, ce qui offre un bon équilibre entre réactivité (les modifications sont détectées rapidement) et efficacité (le système ne gaspille pas de ressources en vérifiant les modifications trop fréquemment).
Gestion des Erreurs : Comme toutes nos fonctions, le processus de configuration inclut une gestion complète des erreurs pour garantir que les problèmes de création de déclencheur sont correctement journalisés et n’interrompent pas l’automatisation.
Journalisation de Confirmation : La fonction fournit une confirmation claire lorsque la synchronisation automatique est configurée avec succès, incluant des détails sur le dossier surveillé.
Vous n’avez besoin d’exécuter cette fonction qu’une seule fois pour établir la synchronisation automatique. Après son exécution, la fonction autoSync() s’exécutera automatiquement toutes les 5 minutes, vérifiant les modifications de documents et les traitant selon les besoins.
La fonction de synchronisation automatique est conçue pour être très efficace en ne traitant que les documents qui ont été modifiés récemment. Cette approche minimise l’utilisation de l’API et le temps de traitement tout en garantissant que les modifications sont détectées et synchronisées rapidement.
/**
* Automatically checks for modified documents and syncs them
* This function is called automatically every 5 minutes
*/
function autoSync() {
try {
console.log('Running auto-sync check...');
const folder = DriveApp.getFolderById(CONFIG.MONITORED_FOLDER_ID);
const files = folder.getFilesByType(MimeType.GOOGLE_DOCS);
// Check for files modified in the last 5 minutes
const lastCheck = new Date(Date.now() - 5 * 60 * 1000);
let modifiedCount = 0;
while (files.hasNext()) {
const file = files.next();
// Check if file was modified recently
if (file.getLastUpdated() > lastCheck) {
console.log(`Auto-syncing recently modified document: ${file.getName()}`);
syncDocument(file);
modifiedCount++;
}
}
if (modifiedCount === 0) {
console.log('No recently modified documents found');
} else {
console.log(`Synced ${modifiedCount} modified document(s)`);
}
} catch (error) {
console.error('Error in periodic sync:', error);
}
}
Cette fonction met en valeur plusieurs techniques d’optimisation qui rendent la synchronisation automatique efficace et fiable :
Filtrage Basé sur l’Horodatage : La fonction ne traite que les documents qui ont été modifiés au cours des 5 dernières minutes (correspondant à la fréquence du déclencheur). Cela réduit considérablement le nombre de documents à vérifier à chaque exécution.
Traitement Minimal : En vérifiant les horodatages de modification avant d’effectuer un traitement lourd (comme la conversion de format ou les appels API), la fonction minimise l’utilisation des ressources lorsqu’aucune modification n’a eu lieu.
Suivi des Performances : La fonction suit et rapporte le nombre de documents réellement synchronisés, offrant une visibilité et aidant à identifier les problèmes potentiels.
Fonctionnement Non Perturbateur : Si aucun document n’a été modifié, la fonction se termine rapidement sans effectuer d’opérations inutiles. Cela garantit que la synchronisation automatique n’affecte pas les performances lorsqu’il n’y a aucun travail à effectuer.
Gestion Cohérente des Erreurs : Même les fonctions automatisées incluent une gestion complète des erreurs pour garantir que les problèmes temporaires ne cassent pas définitivement le système de synchronisation.
L’intervalle de synchronisation de 5 minutes offre un équilibre optimal entre réactivité et efficacité. Les modifications apportées aux Google Docs seront reflétées dans les modèles DocuGenerate en moins de 5 minutes, ce qui est suffisamment rapide pour la plupart des workflows métier tout en restant respectueux des ressources système.
Avant de déployer votre solution de synchronisation pour une utilisation régulière, il est important de tester soigneusement tous les composants pour s’assurer qu’ils fonctionnent correctement avec votre dossier Google Drive et votre configuration de compte DocuGenerate spécifiques. Des tests appropriés permettent d’identifier tout problème de configuration et de confirmer que la logique de synchronisation gère correctement divers scénarios.
Commencez par tester la fonction de synchronisation manuelle, qui fournit un retour immédiat et aide à établir les connexions initiales entre vos Google Docs et les modèles DocuGenerate.
Créez quelques Google Docs de test dans votre dossier surveillé avec différents types de contenu (texte simple, texte formaté, tableaux, images) pour vous assurer que le processus de conversion gère correctement les différents types de documents. Pour ce tutoriel, nous allons utiliser les modèles Software licensing agreement et General release of liability de Google Docs.
Exécutez la fonction manualSync() depuis l’éditeur Apps Script et surveillez le journal d’exécution. Vous devriez voir un résultat détaillé montrant quels documents sont traités et si les modèles sont créés avec succès.
Vérifiez votre compte DocuGenerate pour confirmer que de nouveaux modèles ont été créés avec les bons noms et le bon contenu. Les modèles doivent conserver tout le formatage des Google Docs d’origine.
Ce test initial confirme que votre automatisation de synchronisation est correctement configurée et peut créer avec succès de nouveaux modèles à partir de vos Google Docs. Une fois la synchronisation manuelle fonctionnelle, vous êtes prêt à configurer la synchronisation automatique.
Une fois la synchronisation manuelle fonctionnelle, il est temps de tester le système de synchronisation automatique qui constitue le cœur de votre workflow de synchronisation continu. Ce processus est plus complexe car il repose sur des déclencheurs temporels et des algorithmes de détection des modifications pour identifier les documents à mettre à jour.
Exécutez la fonction setupAutoSync() pour créer le déclencheur temporel. Vous devriez voir des journaux détaillés confirmant que la configuration de la synchronisation automatique s’est terminée avec succès.
Après avoir exécuté la fonction de configuration, il est important de vérifier que le déclencheur a été créé avec succès et configuré avec les bons paramètres. Accédez à la section Triggers dans la barre latérale gauche de l’éditeur Apps Script pour voir tous les déclencheurs associés à votre projet. Vous devriez voir un nouveau déclencheur temporel qui appelle la fonction autoSync toutes les 5 minutes.
Modifiez vos documents de test et attendez le prochain cycle de synchronisation automatique (jusqu’à 5 minutes). L’automatisation devrait détecter la modification et mettre à jour le modèle DocuGenerate correspondant. Dans notre cas, nous avons supprimé la surbrillance verte des balises de fusion pour déclencher la mise à jour du document, ce qui représente un changement de formatage typique que les équipes pourraient effectuer lors de sessions d’édition collaborative.
Surveillez les journaux d’exécution d’Apps Script pour confirmer que la fonction de synchronisation automatique a détecté vos modifications et les a correctement traitées. Les journaux d’exécution ci-dessous montrent le système identifiant les documents récemment modifiés et mettant à jour avec succès les modèles DocuGenerate correspondants.
Enfin, connectez-vous à votre compte DocuGenerate et vérifiez que les modifications apportées à vos Google Docs ont été correctement synchronisées avec les modèles correspondants. Vérifiez que les changements de formatage, les modifications de texte et toute mise à jour structurelle sont fidèlement reflétés dans le contenu du modèle. Cette étape de vérification termine le cycle de test et confirme que votre solution de synchronisation automatique fonctionne correctement.
Une fois le test de la synchronisation automatique terminé, votre système de synchronisation est maintenant pleinement opérationnel et continuera à surveiller votre dossier Google Drive pour détecter les modifications toutes les 5 minutes, garantissant que vos modèles DocuGenerate restent à jour sans aucun effort manuel.
Le workflow de synchronisation que nous avons construit fournit une base solide qui peut être étendue avec des fonctionnalités supplémentaires en fonction de vos besoins spécifiques. Ces améliorations transformeraient l’automatisation de synchronisation de base en une solution complète de gestion des modèles.
Prise en Charge de Plusieurs Dossiers : Modifiez le script pour surveiller simultanément plusieurs dossiers Google Drive, chacun pouvant se synchroniser avec différents comptes DocuGenerate ou selon différentes règles de traitement.
Synchronisation Sélective : Mettez en œuvre un filtrage des documents basé sur des modèles de nommage, des propriétés de documents ou des balises de métadonnées pour vous donner un contrôle précis sur les documents synchronisés.
Prise en Charge des Points de Terminaison Régionaux : Sélectionnez automatiquement les points de terminaison régionaux DocuGenerate optimaux en fonction de votre emplacement géographique ou de la répartition de votre équipe.
Prise en Charge de Formats Étendus : Étendez la solution pour gérer les documents Microsoft Word stockés dans Google Drive, offrant des capacités de synchronisation pour les équipes qui travaillent avec des formats de documents mixtes.
Synchronisation des Suppressions de Documents : Mettez en œuvre une logique pour gérer les suppressions de documents dans Google Drive en supprimant les modèles correspondants dans DocuGenerate.
Nettoyage des Modèles : Créez des fonctions pour identifier et nettoyer les modèles orphelins dans DocuGenerate qui n’ont plus de Google Docs correspondants.
Synchroniser Google Docs avec DocuGenerate élimine les frictions manuelles qui empêchent souvent les équipes de maintenir des modèles à jour tout en exploitant de puissantes capacités de génération de documents. Le système automatisé que nous avons construit comble le fossé entre l’édition collaborative de documents et la génération professionnelle de documents, permettant à votre équipe de travailler naturellement dans Google Docs tout en garantissant que vos modèles DocuGenerate reflètent toujours les dernières modifications.
En mettant en œuvre cette solution, votre équipe peut continuer à utiliser Google Docs pour le développement collaboratif de modèles tout en bénéficiant des capacités avancées de génération de documents que fournit DocuGenerate. La synchronisation automatique garantit que les modifications apportées lors des sessions d’édition collaborative sont immédiatement disponibles pour les workflows de génération de documents, créant une combinaison puissante d’outils qui améliore à la fois la productivité et la qualité des documents.
La conception modulaire de notre solution de synchronisation la rend facile à personnaliser et à étendre selon vos besoins spécifiques. Que vous ayez besoin de surveiller plusieurs dossiers, de mettre en œuvre des règles de filtrage personnalisées, ou d’intégrer des systèmes supplémentaires, la base que nous avons établie fournit une plateforme robuste pour les futures améliorations.
Saisissez votre e-mail pour recevoir la dernière newsletter de DocuGenerate
Ce tutoriel approfondi montre comment améliorer l'application Health Plan Selector dans Power Apps avec une génération automatisée de documents grâce à DocuGenerate, pour créer des propositions PDF professionnelles qui résument des recommandations personnalisées de plan santé.
Découvrez comment créer un analyseur de CV intelligent qui traite automatiquement les candidatures à l'aide de Pipedream, Claude AI et DocuGenerate. Ce tutoriel étape par étape montre comment extraire les données clés des CV et les utiliser pour créer des rapports PDF.
Découvrez comment créer un workflow automatisé de génération de factures avec n8n et DocuGenerate qui surveille un dossier pour les fichiers Excel, extrait les données et génère des factures PDF professionnelles. Idéal pour un traitement local sans dépendre de multiples solutions cloud.